import { Callout, Sandpack } from '@/components'

# useSuspenseQuery

<Callout type='warning'>

**Deprecated in @suspensive/react-query**

This hook is now officially supported in TanStack Query v4.40.0+. Since TanStack Query has backported this interface, we are deprecating the backported version from @suspensive/react-query. Please migrate to the official TanStack Query interface:

```diff
- import { useSuspenseQuery } from '@suspensive/react-query'
+ import { useSuspenseQuery } from '@tanstack/react-query'
```

For more details, see [TanStack Query PR #9140](https://github.com/TanStack/query/pull/9140).

</Callout>

There is no isLoading or isError in the return type of this hook. This is because `<Suspense/>` and `<ErrorBoundary/>` guarantee the data of this hook. Also, in the options of this hook, suspense is set to true by default. Any new options you need can be used like @tanstack/react-query's [useQuery](https://tanstack.com/query/v4/docs/react/reference/useQuery).

```tsx /useSuspenseQuery/
import { useSuspenseQuery } from '@suspensive/react-query'

const Example = () => {
  const query = useSuspenseQuery({
    queryKey,
    queryFn,
  }) // suspense: true is the default.

  // No type narrowing required with isSuccess.
  query.data // TData
}
```

<Sandpack>

```tsx Post.tsx active
import { useSuspenseQuery } from '@suspensive/react-query'
import { getPost } from './api'

export const Post = ({ postId }: { postId: number }) => {
  const { data } = useSuspenseQuery({
    queryKey: ['posts', postId],
    queryFn: () => getPost(postId),
  })

  return (
    <div>
      <h1>{data.title}</h1>
      <p>{data.body}</p>
    </div>
  )
}
```

```tsx Example.tsx
import { Suspense } from '@suspensive/react'
import { useState } from 'react'
import { Post } from './Post'

export const Example = () => {
  const [postId, setPostId] = useState(1)

  return (
    <div>
      <button
        onClick={() => setPostId((prev) => prev - 1)}
        disabled={postId === 1}
      >
        Previous Post
      </button>
      <button
        onClick={() => setPostId((prev) => prev + 1)}
        disabled={postId === 100}
      >
        Next Post
      </button>
      <Suspense fallback={<div>Loading...</div>}>
        <Post postId={postId} />
      </Suspense>
    </div>
  )
}
```

```tsx /api.ts
type Post = {
  userId: number
  id: number
  title: string
  body: string
}

export const getPost = async (id: number): Promise<Post> => {
  const response = await fetch(
    `https://jsonplaceholder.typicode.com/posts/${id}`
  )

  if (!response.ok) {
    throw new Error('An error occurred')
  }

  const data = await response.json()

  return data
}
```

</Sandpack>

### motivation

You can use [useQuery](https://tanstack.com/query/v4/docs/react/reference/useQuery) with `<Suspense/>` and `<ErrorBoundary/>` by using the suspense option in @tanstack/react-query.

```tsx /useQuery/
import { useQuery } from '@tanstack/react-query'

const Example = () => {
  const query = useQuery({
    queryKey,
    queryFn,
    suspense: true,
  })

  query.data // TData | undefined

  if (query.isSuccess) {
    query.data // TData
  }
}
```

The return type of useQuery (query.data) will always be a success case thanks to this component's parents, `<Suspense/>` and `<ErrorBoundary/>`.
But @tanstack/react-query doesn't express this typescript typely.

That's why @suspensive/react-query provides **useSuspenseQuery**.

<Callout>

Focus on successful cases.

Now we can focus only on successful cases as fetching always succeeds inside our component.

</Callout>

### Version History

| Version  | Changes                                                                                                                                   |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `v3.0.0` | `networkMode` has been fixed to `'always'`. For more details, please refer to the [Migration to v3 guide](./migration/migrate-to-v3.mdx). |
